{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CIFAR-10: Part 2\n",
    "\n",
    "Welcome back! If you have not completed [Part 1](*), please do so before running the code in this notebook. \n",
    "\n",
    "In Part 2 we will assume you have the training and testing lmdbs, as well as the trained model .pb files from Part 1. As you may recall from Part 1, we created the dataset in the form of lmdbs then trained a model and saved the trained model in the form of a *predict_net.pb* and an *init_net.pb*. In this notebook, we will show how to test that saved model with the test lmdb and how to continue training to increase our test accuracy.\n",
    "\n",
    "Recall the objectives of the two part CIFAR-10 tutorial:\n",
    "\n",
    "**Part 1:**\n",
    "- Download dataset\n",
    "- Write images to lmdbs\n",
    "- Define and train a model with checkpoints\n",
    "- Save the trained model\n",
    "\n",
    "**Part 2:**\n",
    "- Load pre-trained model from Part 1\n",
    "- Run inference on testing lmdb\n",
    "- Continue training to improve test accuracy\n",
    "- Test the retrained model\n",
    "\n",
    "As before, let's start with some necessary imports."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import absolute_import\n",
    "from __future__ import division\n",
    "from __future__ import print_function\n",
    "from __future__ import unicode_literals\n",
    "import numpy as np\n",
    "import os\n",
    "import shutil\n",
    "import operator\n",
    "import glob\n",
    "from caffe2.python import core,model_helper,optimizer,workspace,brew,utils\n",
    "from caffe2.proto import caffe2_pb2\n",
    "import matplotlib.pyplot as plt \n",
    "from caffe2.python.modeling import initializers\n",
    "from caffe2.python.modeling.parameter_info import ParameterTags"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check Inputs\n",
    "\n",
    "Before we get started, let's make sure you have the necessary Part 1 files. We will use the saved model from the most recent run of Part 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success, you may continue!\n"
     ]
    }
   ],
   "source": [
    "# Train lmdb\n",
    "TRAIN_LMDB = os.path.join(os.path.expanduser('~'),\"caffe2_notebooks/tutorial_data/cifar10/training_lmdb\")\n",
    "# Test lmdb\n",
    "TEST_LMDB = os.path.join(os.path.expanduser('~'),\"caffe2_notebooks/tutorial_data/cifar10/testing_lmdb\")\n",
    "\n",
    "\n",
    "# Extract protobuf files from most recent Part 1 run\n",
    "part1_runs_path = os.path.join(os.path.expanduser('~'), \"caffe2_notebooks\", \"tutorial_files\", \"tutorial_cifar10\")\n",
    "runs = sorted(glob.glob(part1_runs_path + \"/*\"))\n",
    "\n",
    "# Init net\n",
    "INIT_NET = os.path.join(runs[-1], \"cifar10_init_net.pb\")\n",
    "# Predict net\n",
    "PREDICT_NET = os.path.join(runs[-1], \"cifar10_predict_net.pb\")\n",
    "\n",
    "\n",
    "# Make sure they all exist\n",
    "if (not os.path.exists(TRAIN_LMDB)) or (not os.path.exists(TEST_LMDB)) or (not os.path.exists(INIT_NET)) or (not os.path.exists(PREDICT_NET)):\n",
    "    print(\"ERROR: input not found!\")\n",
    "else:\n",
    "    print(\"Success, you may continue!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Repeat Helper Functions\n",
    "\n",
    "If these functions look familiar, you are correct; they have been copied-and-pasted from Part 1. To summarize, we will need the *AddInputLayer* function to connect our models to the lmdbs, and the *Add_Original_CIFAR10_Model* function to provide the architecture of the network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def AddInputLayer(model, batch_size, db, db_type):\n",
    "    # load the data\n",
    "    #data_uint8, label = brew.db_input(\n",
    "    #    model,\n",
    "    #   blobs_out=[\"data_uint8\", \"label\"],\n",
    "    #   batch_size=batch_size,\n",
    "    #   db=db,\n",
    "    #    db_type=db_type,\n",
    "    #)\n",
    "    data_uint8, label = model.TensorProtosDBInput([], [\"data_uint8\", \"label\"], batch_size=batch_size, db=db, db_type=db_type)\n",
    "    # cast the data to float\n",
    "    data = model.Cast(data_uint8, \"data\", to=core.DataType.FLOAT)\n",
    "    # scale data from [0,255] down to [0,1]\n",
    "    data = model.Scale(data, data, scale=float(1./256))\n",
    "    # don't need the gradient for the backward pass\n",
    "    data = model.StopGradient(data, data)\n",
    "    return data, label\n",
    "\n",
    "def update_dims(height, width, kernel, stride, pad):\n",
    "    new_height = ((height - kernel + 2*pad)//stride) + 1\n",
    "    new_width = ((width - kernel + 2*pad)//stride) + 1\n",
    "    return new_height, new_width\n",
    "\n",
    "def Add_Original_CIFAR10_Model(model, data, num_classes, image_height, image_width, image_channels):\n",
    "    # Convolutional layer 1\n",
    "    conv1 = brew.conv(model, data, 'conv1', dim_in=image_channels, dim_out=32, kernel=5, stride=1, pad=2)\n",
    "    h,w = update_dims(height=image_height, width=image_width, kernel=5, stride=1, pad=2)\n",
    "    # Pooling layer 1\n",
    "    pool1 = brew.max_pool(model, conv1, 'pool1', kernel=3, stride=2)\n",
    "    h,w = update_dims(height=h, width=w, kernel=3, stride=2, pad=0)\n",
    "    # ReLU layer 1\n",
    "    relu1 = brew.relu(model, pool1, 'relu1')\n",
    "    \n",
    "    # Convolutional layer 2\n",
    "    conv2 = brew.conv(model, relu1, 'conv2', dim_in=32, dim_out=32, kernel=5, stride=1, pad=2)\n",
    "    h,w = update_dims(height=h, width=w, kernel=5, stride=1, pad=2)\n",
    "    # ReLU layer 2\n",
    "    relu2 = brew.relu(model, conv2, 'relu2')\n",
    "    # Pooling layer 1\n",
    "    pool2 = brew.average_pool(model, relu2, 'pool2', kernel=3, stride=2)\n",
    "    h,w = update_dims(height=h, width=w, kernel=3, stride=2, pad=0)\n",
    "    \n",
    "    # Convolutional layer 3\n",
    "    conv3 = brew.conv(model, pool2, 'conv3', dim_in=32, dim_out=64, kernel=5, stride=1, pad=2)\n",
    "    h,w = update_dims(height=h, width=w, kernel=5, stride=1, pad=2)\n",
    "    # ReLU layer 3\n",
    "    relu3 = brew.relu(model, conv3, 'relu3')\n",
    "    # Pooling layer 3\n",
    "    pool3 = brew.average_pool(model, relu3, 'pool3', kernel=3, stride=2)\n",
    "    h,w = update_dims(height=h, width=w, kernel=3, stride=2, pad=0)\n",
    "    \n",
    "    # Fully connected layers\n",
    "    fc1 = brew.fc(model, pool3, 'fc1', dim_in=64*h*w, dim_out=64)\n",
    "    fc2 = brew.fc(model, fc1, 'fc2', dim_in=64, dim_out=num_classes)\n",
    "    \n",
    "    # Softmax layer\n",
    "    softmax = brew.softmax(model, fc2, 'softmax')\n",
    "    return softmax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test Saved Model From Part 1\n",
    "\n",
    "### Construct Model for Testing\n",
    "\n",
    "The first thing we need is a model helper object that we can attach the lmdb reader to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a ModelHelper object with init_params=False\n",
    "arg_scope = {\"order\": \"NCHW\"}\n",
    "test_model = model_helper.ModelHelper(name=\"test_model\", arg_scope=arg_scope, init_params=False)\n",
    "\n",
    "# Add the data input layer to the model, pointing at the TEST_LMDB\n",
    "data,_ = AddInputLayer(test_model,1,TEST_LMDB,'lmdb')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Populate the Model Helper with Saved Model Params\n",
    "\n",
    "To format a model for testing, we do not need to create params in the model helper, nor do we need to add gradient operators as we will only be performing forward passes. All we really need to do is populate the *.net* and *.param_init_net* members of the model helper with the contents of the saved *predict_net.pb* and *init_net.pb*, respectively. To accomplish this, we construct *caffe2_pb* objects with the protobuf from the pb files, create *Net* objects with the *caffe2_pb* objects, then **append** the net objects to the *.net* and *.param_init_net* members of the model helper. Appending is very important here! If we do not append, we would wipe out the input data layer stuff that we just added.\n",
    "\n",
    "Recall from Part 1, the saved model expected an input named *data* and produced an output called *softmax*. Conveniently (but not accidentally), the *AddInputLayer* function reads from the lmdb and puts the information into the workspace in a blob called *data*. It is also important to remember what each of the saved nets that we are appending to our model contains. The *predict_net* contains the structure of the model, including the ops involved in the forward pass. It has the definitions of the convolutional, pooling, and fc layers in the model. The *init_net* contains the weight initializations for the parameters that the ops in the *predict_net* expect. For example, if there is an op in the *predict_net* named 'fc1', the *init_net* will contain the trained weights (*fc1_w*), and biases (*fc1_b*) for that layer. \n",
    "\n",
    "After we append the nets, we add an accuracy layer to the model which uses the *softmax* output from the saved model and the *label* input from the lmdb. Note, we could manually fetch the softmax blob from the workspace after every iteration and check whether or not the class with the highest softmax score is the true label, but instead we opt for the simpler accuacy layer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Populate the model helper obj with the init net stuff, which provides the \n",
    "#    weight initializations for the model\n",
    "init_net_proto = caffe2_pb2.NetDef()\n",
    "with open(INIT_NET, \"rb\") as f:\n",
    "    init_net_proto.ParseFromString(f.read())\n",
    "test_model.param_init_net = test_model.param_init_net.AppendNet(core.Net(init_net_proto))\n",
    "\n",
    "# Populate the model helper obj with the predict net stuff, which defines \n",
    "#    the structure of the model\n",
    "predict_net_proto = caffe2_pb2.NetDef()\n",
    "with open(PREDICT_NET, \"rb\") as f:\n",
    "    predict_net_proto.ParseFromString(f.read())\n",
    "test_model.net = test_model.net.AppendNet(core.Net(predict_net_proto))\n",
    "\n",
    "# Add an accuracy feature to the model for convenient reporting during testing\n",
    "accuracy = brew.accuracy(test_model, ['softmax', 'label' ], 'accuracy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run Testing\n",
    "\n",
    "At this point, our model is initialized as the saved model from Part 1. We can now run the testing loop and check the accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter: 500, Current Accuracy: 0.654\n",
      "Iter: 1000, Current Accuracy: 0.663\n",
      "Iter: 1500, Current Accuracy: 0.640666666667\n",
      "Iter: 2000, Current Accuracy: 0.643\n",
      "Iter: 2500, Current Accuracy: 0.6356\n",
      "Iter: 3000, Current Accuracy: 0.639333333333\n",
      "Iter: 3500, Current Accuracy: 0.639142857143\n",
      "Iter: 4000, Current Accuracy: 0.63625\n",
      "Iter: 4500, Current Accuracy: 0.636444444444\n",
      "Iter: 5000, Current Accuracy: 0.6352\n",
      "Iter: 5500, Current Accuracy: 0.638181818182\n",
      "Iter: 6000, Current Accuracy: 0.638666666667\n",
      "Iter: 6500, Current Accuracy: 0.638461538462\n",
      "Iter: 7000, Current Accuracy: 0.636428571429\n",
      "Iter: 7500, Current Accuracy: 0.634533333333\n",
      "Iter: 8000, Current Accuracy: 0.63475\n",
      "Iter: 8500, Current Accuracy: 0.633058823529\n",
      "Iter: 9000, Current Accuracy: 0.632111111111\n",
      "Iter: 9500, Current Accuracy: 0.632421052632\n",
      "*********************************************\n",
      "Final Test Accuracy:  0.6321\n"
     ]
    }
   ],
   "source": [
    "# Run the param init net to put the trained model info into the workspace\n",
    "workspace.RunNetOnce(test_model.param_init_net)\n",
    "workspace.CreateNet(test_model.net, overwrite=True)\n",
    "\n",
    "# Stat keeper\n",
    "avg_accuracy = 0.0\n",
    "\n",
    "# Number of test iterations to run here, since the full test set is 10k images and the\n",
    "#  batch size is 1, we will run 10000 test batches to cover the entire test set\n",
    "test_iters = 10000\n",
    "\n",
    "# Main testing loop\n",
    "for i in range(test_iters):\n",
    "    workspace.RunNet(test_model.net)\n",
    "    acc = workspace.FetchBlob('accuracy')\n",
    "    avg_accuracy += acc\n",
    "    if (i % 500 == 0) and (i > 0):\n",
    "        print(\"Iter: {}, Current Accuracy: {}\".format(i, avg_accuracy/float(i)))\n",
    "\n",
    "# Report final test accuracy score as the number of correct predictions divided by 10,000\n",
    "print(\"*********************************************\")\n",
    "print(\"Final Test Accuracy: \",avg_accuracy/float(test_iters))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Continue Training\n",
    "\n",
    "Our model is performing significantly better than random guessing, but I think we can do a little better with more training. To do this we will:\n",
    "- create a new model helper\n",
    "- specify that the train data will come from the training lmdb\n",
    "- re-define the model architecture with the Add_Original_CIFAR10_Model function\n",
    "- grab the trained weights and biases from the saved init_net.pb\n",
    "- resume training\n",
    "\n",
    "### Construct Model for Re-Training\n",
    "\n",
    "Here we create a new model helper object for training. Nothing here should look new but take notice that we set **init_params=False**. This is important, as we do not want brew (in *Add_Original_CIFAR10_Model* function) to automatically initialize the params, rather we want to set them ourselves. Once we construct the model helper, we add the input layer and point it to the training lmdb, brew in the model architecture, and finally initialize the parameters by appending the contents of the saved *init_net.pb* to the *.param_init_net* member of the train model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of iterations to train for here\n",
    "training_iters = 3000\n",
    "\n",
    "# Reset workspace to clear all of the information from the testing stage\n",
    "workspace.ResetWorkspace()\n",
    "\n",
    "# Create new model\n",
    "arg_scope = {\"order\": \"NCHW\"}\n",
    "train_model = model_helper.ModelHelper(name=\"cifar10_train\", arg_scope=arg_scope, init_params=False)\n",
    "\n",
    "# Add the data layer to the model\n",
    "data,_ = AddInputLayer(train_model,100,TRAIN_LMDB,'lmdb')\n",
    "softmax = Add_Original_CIFAR10_Model(train_model, data, 10, 32, 32, 3)\n",
    "\n",
    "# Populate the param_init_net of the model obj with the contents of the init net\n",
    "init_net_proto = caffe2_pb2.NetDef()\n",
    "with open(INIT_NET, \"rb\") as f:\n",
    "    init_net_proto.ParseFromString(f.read())\n",
    "tmp_init_net = core.Net(init_net_proto)\n",
    "train_model.param_init_net = train_model.param_init_net.AppendNet(tmp_init_net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Specify Loss Function and Optimizer\n",
    "\n",
    "We can now proceed as normal by specifying the loss function, adding the gradient operators, and building the optimizier. Here, we opt for the same loss function and optimizer that we used in Part 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<caffe2.python.optimizer.SgdOptimizer at 0x107a9b850>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add the \"training operators\" to the model\n",
    "xent = train_model.LabelCrossEntropy([softmax, 'label'], 'xent')\n",
    "# compute the expected loss\n",
    "loss = train_model.AveragedLoss(xent, \"loss\")\n",
    "# track the accuracy of the model\n",
    "accuracy = brew.accuracy(train_model, [softmax, 'label'], \"accuracy\")\n",
    "# use the average loss we just computed to add gradient operators to the model\n",
    "train_model.AddGradientOperators([loss])\n",
    "# Specify Optimization Algorithm\n",
    "optimizer.build_sgd(\n",
    "    train_model,\n",
    "    base_learning_rate=0.01,\n",
    "    policy=\"fixed\",\n",
    "    momentum=0.9,\n",
    "    weight_decay=0.004\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Important Note**\n",
    "\n",
    "Check out the results of the *GetOptimizationParamInfo* function. The *params* that this function returns are the parameters that will be optimized by the optimization function. If you are attempting to retrain a model in a different way, and your model doesnt seem to be learning, check the return value of this fuction. If it returns nothing, look no further for your problem! This is exactly the reason that we brew'ed in the layers of the train model with the *Add_Original_CIFAR10_Model* function, because it creates the params in the model automatically. If we had appended the *.net* member of the Model Helper as we did for the test model, this function would return nothing, meaning no parameters would get optimized. A workaround if you appended the net would be to manually create the params with the *create_param* function, which feels like a bit of a hack, especially if you have the add model code on-hand. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Param to be optimized:  conv3_b\n",
      "Param to be optimized:  fc2_w\n",
      "Param to be optimized:  fc1_b\n",
      "Param to be optimized:  conv1_b\n",
      "Param to be optimized:  conv2_b\n",
      "Param to be optimized:  conv3_w\n",
      "Param to be optimized:  fc2_b\n",
      "Param to be optimized:  fc1_w\n",
      "Param to be optimized:  conv2_w\n",
      "Param to be optimized:  conv1_w\n"
     ]
    }
   ],
   "source": [
    "for param in train_model.GetOptimizationParamInfo():\n",
    "    print(\"Param to be optimized: \",param)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run Training\n",
    "\n",
    "**This step will take a while!**\n",
    "\n",
    "With our model helper setup we can now run the training as normal. Note, the accuracy and loss reported here is as measured on the *training* batches. Recall that the accuracy reported in Part 1 was the validation accuracy. Be careful how you interpret this number!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter: 0, Loss: 1.02017736435, Accuracy: 0.629999995232\n",
      "Iter: 100, Loss: 1.03627979755, Accuracy: 0.639999985695\n",
      "Iter: 200, Loss: 1.01044285297, Accuracy: 0.649999976158\n",
      "Iter: 300, Loss: 1.11098098755, Accuracy: 0.569999992847\n",
      "Iter: 400, Loss: 0.857563138008, Accuracy: 0.660000026226\n",
      "Iter: 500, Loss: 0.947329521179, Accuracy: 0.689999997616\n",
      "Iter: 600, Loss: 1.03314650059, Accuracy: 0.660000026226\n",
      "Iter: 700, Loss: 0.916410207748, Accuracy: 0.72000002861\n",
      "Iter: 800, Loss: 0.780662596226, Accuracy: 0.730000019073\n",
      "Iter: 900, Loss: 0.84335398674, Accuracy: 0.709999978542\n",
      "Iter: 1000, Loss: 0.813905596733, Accuracy: 0.740000009537\n",
      "Iter: 1100, Loss: 0.696036875248, Accuracy: 0.730000019073\n",
      "Iter: 1200, Loss: 0.901836633682, Accuracy: 0.680000007153\n",
      "Iter: 1300, Loss: 0.892839670181, Accuracy: 0.649999976158\n",
      "Iter: 1400, Loss: 0.832642018795, Accuracy: 0.72000002861\n",
      "Iter: 1500, Loss: 0.771974146366, Accuracy: 0.72000002861\n",
      "Iter: 1600, Loss: 0.926190078259, Accuracy: 0.699999988079\n",
      "Iter: 1700, Loss: 0.884124755859, Accuracy: 0.680000007153\n",
      "Iter: 1800, Loss: 0.891266524792, Accuracy: 0.660000026226\n",
      "Iter: 1900, Loss: 0.633636891842, Accuracy: 0.75\n",
      "Iter: 2000, Loss: 0.643068671227, Accuracy: 0.77999997139\n",
      "Iter: 2100, Loss: 0.827954411507, Accuracy: 0.740000009537\n",
      "Iter: 2200, Loss: 0.845260441303, Accuracy: 0.689999997616\n",
      "Iter: 2300, Loss: 0.806422412395, Accuracy: 0.689999997616\n",
      "Iter: 2400, Loss: 0.742512345314, Accuracy: 0.740000009537\n",
      "Iter: 2500, Loss: 0.785759627819, Accuracy: 0.759999990463\n",
      "Iter: 2600, Loss: 0.530824780464, Accuracy: 0.790000021458\n",
      "Iter: 2700, Loss: 0.726455926895, Accuracy: 0.709999978542\n",
      "Iter: 2800, Loss: 0.945818066597, Accuracy: 0.670000016689\n",
      "Iter: 2900, Loss: 0.67063999176, Accuracy: 0.810000002384\n"
     ]
    }
   ],
   "source": [
    "# Prime the workspace\n",
    "workspace.RunNetOnce(train_model.param_init_net)\n",
    "workspace.CreateNet(train_model.net, overwrite=True)\n",
    "\n",
    "# Run the training loop\n",
    "for i in range(training_iters):\n",
    "    workspace.RunNet(train_model.net)\n",
    "    acc = workspace.FetchBlob('accuracy')\n",
    "    loss = workspace.FetchBlob('loss')\n",
    "    if i % 100 == 0:\n",
    "        print (\"Iter: {}, Loss: {}, Accuracy: {}\".format(i,loss,acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test the Retrained Model\n",
    "\n",
    "We will test the retrained model, just as we did in the first part of this notebook. However, since the params already exist in the workspace from the retraining step, we do not need to set the *.param_init_net*. Rather, we set **init_params=False** and brew in the model architecture with *Add_Original_CIFAR10_Model*. When we create the net, the model will find that the required blobs are already in the workspace. Then, we can run the main testing loop, which will report a final test accuracy score (which is hopefully higher)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter: 500, Current Accuracy: 0.712\n",
      "Iter: 1000, Current Accuracy: 0.721\n",
      "Iter: 1500, Current Accuracy: 0.718\n",
      "Iter: 2000, Current Accuracy: 0.713\n",
      "Iter: 2500, Current Accuracy: 0.71\n",
      "Iter: 3000, Current Accuracy: 0.716\n",
      "Iter: 3500, Current Accuracy: 0.72\n",
      "Iter: 4000, Current Accuracy: 0.71675\n",
      "Iter: 4500, Current Accuracy: 0.719555555556\n",
      "Iter: 5000, Current Accuracy: 0.7194\n",
      "Iter: 5500, Current Accuracy: 0.720363636364\n",
      "Iter: 6000, Current Accuracy: 0.721166666667\n",
      "Iter: 6500, Current Accuracy: 0.720461538462\n",
      "Iter: 7000, Current Accuracy: 0.719571428571\n",
      "Iter: 7500, Current Accuracy: 0.7188\n",
      "Iter: 8000, Current Accuracy: 0.7185\n",
      "Iter: 8500, Current Accuracy: 0.718235294118\n",
      "Iter: 9000, Current Accuracy: 0.718\n",
      "Iter: 9500, Current Accuracy: 0.717157894737\n",
      "*********************************************\n",
      "Final Test Accuracy:  0.7169\n"
     ]
    }
   ],
   "source": [
    "arg_scope = {\"order\": \"NCHW\"}\n",
    "# Construct the model\n",
    "test_model = model_helper.ModelHelper(name=\"test_model\", arg_scope=arg_scope, init_params=False)\n",
    "# Set the input as the test lmdb\n",
    "data,_ = AddInputLayer(test_model,1,TEST_LMDB,'lmdb')\n",
    "# brew in the model architecture\n",
    "softmax = Add_Original_CIFAR10_Model(test_model, data, 10, 32, 32, 3)\n",
    "accuracy = brew.accuracy(test_model, ['softmax', 'label' ], 'accuracy')\n",
    "# Prime the net\n",
    "workspace.RunNetOnce(test_model.param_init_net)\n",
    "workspace.CreateNet(test_model.net, overwrite=True)\n",
    "\n",
    "# Confusion Matrix for CIFAR-10\n",
    "cmat = np.zeros((10,10))\n",
    "\n",
    "# Stat keepers\n",
    "avg_accuracy = 0.0\n",
    "test_iters = 10000\n",
    "\n",
    "# Main testing loop\n",
    "for i in range(test_iters):\n",
    "    workspace.RunNet(test_model.net)\n",
    "    acc = workspace.FetchBlob('accuracy')\n",
    "    avg_accuracy += acc\n",
    "    if (i % 500 == 0) and (i > 0):\n",
    "        print(\"Iter: {}, Current Accuracy: {}\".format(i, avg_accuracy/float(i)))\n",
    "        \n",
    "    # Get the top-1 prediction\n",
    "    results = workspace.FetchBlob('softmax')[0]\n",
    "    label = workspace.FetchBlob('label')[0]\n",
    "    max_index, max_value = max(enumerate(results), key=operator.itemgetter(1))    \n",
    "    # Update confusion matrix\n",
    "    cmat[label,max_index] += 1\n",
    "\n",
    "# Report final testing results\n",
    "print(\"*********************************************\")\n",
    "print(\"Final Test Accuracy: \",avg_accuracy/float(test_iters))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check Results\n",
    "\n",
    "Notice, the result from testing the re-trained model is better than the original test accuracy. If you wish, you can save the new model as .pb files just as in Part 1, but we will leave that to you. The last thing we will do is attempt to visualize the performance of our classifier by plotting a confusion matrix and looking for a **strong diagonal** trend."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot confusion matrix\n",
    "fig = plt.figure(figsize=(10,10))\n",
    "plt.tight_layout()\n",
    "ax = fig.add_subplot(111)\n",
    "res = ax.imshow(cmat, cmap=plt.cm.rainbow,interpolation='nearest')\n",
    "width, height = cmat.shape\n",
    "for x in xrange(width):\n",
    "    for y in xrange(height):\n",
    "        ax.annotate(str(cmat[x,y]), xy=(y, x),horizontalalignment='center',verticalalignment='center')\n",
    "\n",
    "classes = ['Airplane','Automobile','Bird','Cat','Deer','Dog','Frog','Horse','Ship','Truck']\n",
    "plt.xticks(range(width), classes, rotation=0)\n",
    "plt.yticks(range(height), classes, rotation=0)\n",
    "ax.set_xlabel('Predicted Class')\n",
    "ax.set_ylabel('True Class')\n",
    "plt.title('CIFAR-10 Confusion Matrix')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
